﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace Systemet.Domain
{

    public partial class KostnadsBudgController
    {
        private Views.Resursallokering rA;
        private SideViews.SideKostnadsbudgetering sKB;
        private Technical.KostnadsbudConnection kC = new Technical.KostnadsbudConnection();
        private Technical.AktivitetConnection aC;
        private Domain.ProdukController pC;

        //ResursallokeringsVariabler
        DataTable dt;
        private List<Personal> staff;
        private IEnumerable<Produktregister> products;
        private List<ResursAllokeringar> Prodallocations;
        private List<AktivitetsAllokeringar> activityAllocations;
        private IEnumerable<Aktivietetsregister> activities;

        //Direktkostnadsbudgetering
        private Technical.ProduktConnection pRC;
        private Views.Direktkostnadsbudgetering DirKostBudgMain;
        private Domain.KontoController kontC;
        private string currentDepartment;

        //Kostnadsrapporter
        private Views.Kostnadsrapporter kR;

        public void ClearDGV()
        {
            rA = (Views.Resursallokering)AccessController.Instance.MainView;
            rA.ClearDgv();
        }
        public void ClearKrDgv()
        {
            kR = (Views.Kostnadsrapporter)AccessController.Instance.MainView;
            kR.ClearReportDGV();
        }

        //Kostnadsrapporter personalrelaterade kostnader på produkter och avd
        public void CostReportOnStaffCostsNProducts(string prodomr)
        {
            kC = new Technical.KostnadsbudConnection();
            List<Personal> StaffList = kC.RetrieveStaffAllocations(prodomr);
            List<Personalavdelning> avdelningsallokeringar = kC.RetrieveStaffPercentages();
            List<ResursAllokeringar> Productallocations = kC.GetAllocations();
            Productallocations = FilterResursAllokeringar(Productallocations, prodomr);
            avdelningsallokeringar = filterStaffAllocations(avdelningsallokeringar, prodomr);

            kR = (Views.Kostnadsrapporter)AccessController.Instance.MainView;
            kR.createDatatableProducts(prodomr, StaffList, avdelningsallokeringar, Productallocations);
        }

        public void CostReportOnStaffCostsNActivities(string prodomr)
        {
            kC = new Technical.KostnadsbudConnection();
            aC = new Technical.AktivitetConnection();
            List<Personal> StaffList = kC.RetrieveStaffAllocations(prodomr);
            List<Personalavdelning> avdelningsallokeringar = kC.RetrieveStaffPercentages();
            List<AktivitetsAllokeringar> activityAllocations = kC.GetActivityAllocations(prodomr);
            avdelningsallokeringar = filterStaffAllocations(avdelningsallokeringar, prodomr);
            activityAllocations = FilterActivityAllokeringar(activityAllocations, prodomr);
            IEnumerable<Aktivietetsregister> activities = aC.getFiltreringskriterier();
            kR = (Views.Kostnadsrapporter)AccessController.Instance.MainView;
            kR.createDatatableActivities(prodomr, StaffList, avdelningsallokeringar, activityAllocations, activities);
        }
        //Rapportval direktkostnad på avd
        public void DirectCostreportOnDepartment(string avd)
        {
            string kontoFran = "0";
            string kontoTill = ChangeAccName("");
            kR = (Views.Kostnadsrapporter)AccessController.Instance.MainView;

            if (avd.Contains("Drift") || avd.Contains("Förv"))
            {
                pC = new ProdukController();
                kC = new Technical.KostnadsbudConnection();
                products = pC.Produktlista;
                products = filterProducts(avd);
                List<ProduktKostnad> productCosts = kC.RetrieveProductCosts(kontoFran, kontoTill, avd);

                kR.createDataTableDirectcostProducts(avd, products, productCosts);
            }
            if (avd.Contains("mark") || avd.Contains("Adm"))
            {
                aC = new Technical.AktivitetConnection();
                activities = aC.getFiltreringskriterier();
                activities = filterActivities(avd);
                List<AktivitetsKostnad> activityCosts = kC.RetrieveActivityCosts(kontoFran, kontoTill, avd);
                kR.createDataTableDirectcostActivities(avd, activities, activityCosts);
            }
        }
        //Filtrera ut Aktiviteter på basis av produktionsområde
        private List<Aktivietetsregister> filterActivities(string avd)
        {
            List<Aktivietetsregister> tempProducts = new List<Aktivietetsregister>();
            tempProducts.Clear();
            foreach (Aktivietetsregister a in activities)
            {
                if (a.avdelningsnamn.Contains(avd))
                {
                    tempProducts.Add(a);
                }
            }
            return tempProducts;
        }
        //Filtrera ut produkter på basis av produktionsområde
        private IEnumerable<Produktregister> filterProducts(string avd)
        {
            List<Produktregister> tempProducts = new List<Produktregister>();
            tempProducts.Clear();
            foreach (Produktregister p in products)
            {
                if (p.avdelningsnamn.Contains(avd))
                {
                    tempProducts.Add(p);
                }
            }
            return tempProducts;
        }

        //Filtrera ut Aktivitetsallokeringar beroende på valt sökkriterie
        private List<AktivitetsAllokeringar> FilterActivityAllokeringar(List<AktivitetsAllokeringar> allo, string avd)
        {
            List<AktivitetsAllokeringar> tempAllos = new List<AktivitetsAllokeringar>();
            foreach (AktivitetsAllokeringar aA in allo)
            {
                if (aA.Avdelningsnamn.Contains(avd))
                {
                    tempAllos.Add(aA);
                }

            }
            return tempAllos;
        }


        //Filtrera ut Produktallokeringar beroende på valt sökkriterie
        private List<ResursAllokeringar> FilterResursAllokeringar(List<ResursAllokeringar> allo, string avd)
        {
            List<ResursAllokeringar> tempAllos = new List<ResursAllokeringar>();
            foreach (ResursAllokeringar rA in allo)
            {
                if (rA.Avdelningsnamn.Contains(avd))
                {
                    tempAllos.Add(rA);
                }

            }
            return tempAllos;
        }
        //Filtrera ut pesonalavdelningar beroende på valt sökkriterie
        private List<Personalavdelning> filterStaffAllocations(List<Personalavdelning> staff, string avd)
        {
            List<Personalavdelning> tempStaff = new List<Personalavdelning>();
            foreach (Personalavdelning p in staff)
            {
                if (p.avdelningsnamn.Contains(avd))
                {
                    tempStaff.Add(p);
                }
            }
            return tempStaff;
        }

        /// <summary>
        /// Ändra inte nu åtminstone, använder sig av många olika typer av listor 
        /// Hämta produkter/Aktiviteter och allokeringar och personal
        /// </summary>
        public void RetrieveStaffNProducts(string prodgrupp, string prodKategori, string prodOmrade)
        {
            kC = new Technical.KostnadsbudConnection();
            rA = (Views.Resursallokering)AccessController.Instance.MainView;
            aC = new Technical.AktivitetConnection();

            List<Personal> StaffList = kC.RetrieveStaffAllocations(prodOmrade);
            IEnumerable<Aktivietetsregister> activities = aC.getFiltreringskriterier();
            List<ResursAllokeringar> Productallocations = kC.GetAllocations();
            List<Personalavdelning> avdelningsallokeringar = kC.RetrieveStaffPercentages();
            List<AktivitetsAllokeringar> activityAllocations = kC.GetActivityAllocations(prodOmrade);

            rA.UpdateDgVAllocations(kC.RetrieveProductionAllocations(prodgrupp, prodKategori, prodOmrade), StaffList, Productallocations, activities, activityAllocations, prodOmrade, avdelningsallokeringar);
        }

        public bool ValidateStaffOnProductAllocation(string persNr, string newAllocation, string oldAllocation, string AllocationName, string prodomrade, bool isNewAllocation)
        {
            kC = new Technical.KostnadsbudConnection();
            sKB = (SideViews.SideKostnadsbudgetering)AccessController.Instance.SidMeny;
            aC = new Technical.AktivitetConnection();
            bool IsSuccessfull = false;
            List<Personal> StaffList = kC.RetrieveStaffAllocations(prodomrade);
            IEnumerable<Aktivietetsregister> activities = aC.getFiltreringskriterier();
            List<ResursAllokeringar> Productallocations = kC.GetAllocations();
            List<Personalavdelning> avdelningsallokeringar = kC.RetrieveStaffPercentages();

            List<AktivitetsAllokeringar> activityAllocations = kC.GetActivityAllocations(prodomrade);
            int currentAvdPossibleAllocation = 0;
            int usedAllocations = 0;

            //Om det är en NY allokering

            //MaxAllokering på den avdelning man jobbar i och  nuvarande allokering på denna avd

            //<<<<<<< .mine
            //                foreach (Personalavdelning pA in avdelningsallokeringar)
            //=======
            foreach (Personalavdelning pA in avdelningsallokeringar)
            {
                if (persNr == pA.personnummer && pA.avdelningsnamn.Contains(prodomrade))
                //>>>>>>> .r1014
                {
                    if (pA.avdelningsnamn.Contains(prodomrade))
                    {
                        currentAvdPossibleAllocation = currentAvdPossibleAllocation + pA.procentsats;
                    }
                }
            }

            if (isNewAllocation)
            {
                if (prodomrade.Contains("Adm") || prodomrade.Contains("mark"))
                {
                    usedAllocations = kC.CheckStaffAllocationsOnActivities(persNr, prodomrade);

                    if (int.Parse(newAllocation) > currentAvdPossibleAllocation)
                    {
                        return false;
                    }
                    if (int.Parse(newAllocation) > (currentAvdPossibleAllocation - usedAllocations))
                    {
                        return false;
                    }
                    if (int.Parse(newAllocation) <= (currentAvdPossibleAllocation - usedAllocations))
                    {
                        IsSuccessfull = InsertNewActivityAllocation(persNr, AllocationName, newAllocation, prodomrade);
                        if (IsSuccessfull)
                        {
                            if (prodomrade.Contains("Adm"))
                            {
                                sKB.checkBoxResursAdm.Focus();
                                sKB.checkBoxResursAdm.Checked = !sKB.checkBoxResursAdm.Checked;
                            }
                            if (prodomrade.Contains("mark"))
                            {
                                sKB.checkBoxResursForsMark.Focus();
                                sKB.checkBoxResursForsMark.Checked = !sKB.checkBoxResursForsMark.Checked;
                            }
                            return IsSuccessfull;
                        }
                        else
                        {
                            return IsSuccessfull;
                        }
                    }
                }
                if (prodomrade.Contains("Drift") || prodomrade.Contains("Förv"))
                {
                    usedAllocations = kC.CheckStaffAllocationsOnProducts(persNr, prodomrade);

                    if (int.Parse(newAllocation) > currentAvdPossibleAllocation)
                    {
                        return false;
                    }
                    if (int.Parse(newAllocation) > (currentAvdPossibleAllocation - usedAllocations))
                    {
                        return false;
                    }
                    if (int.Parse(newAllocation) <= (currentAvdPossibleAllocation - usedAllocations))
                    {
                        IsSuccessfull = InsertNewProductAllocation(persNr, AllocationName, newAllocation, prodomrade);
                        if (IsSuccessfull)
                        {
                            TriggerDGVupdate();
                            return IsSuccessfull;
                        }
                        else
                        {
                            return IsSuccessfull;
                        }
                    }

                }

            }
            if (!isNewAllocation)
            {

                if (prodomrade.Contains("Adm") || prodomrade.Contains("mark"))
                {
                    usedAllocations = kC.CheckStaffAllocationsOnActivities(persNr, prodomrade);

                    int newUsedAllocations = usedAllocations - int.Parse(oldAllocation) + int.Parse(newAllocation);
                    int disponibelt = currentAvdPossibleAllocation - newUsedAllocations;
                    if (disponibelt >= 0)
                    {
                        IsSuccessfull = UpdateStaffAllocationOnActivity(persNr, AllocationName, newAllocation, prodomrade);
                        return IsSuccessfull;
                    }

                }
                if (prodomrade.Contains("Drift") || prodomrade.Contains("Förv"))
                {
                    usedAllocations = kC.CheckStaffAllocationsOnProducts(persNr, prodomrade);

                    int newUsedAllocations = usedAllocations - int.Parse(oldAllocation) + int.Parse(newAllocation);
                    int disponibelt = currentAvdPossibleAllocation - newUsedAllocations;

                    if (disponibelt >= 0)
                    {
                        IsSuccessfull = UpdateStaffAllocationOnProduct(persNr, AllocationName, newAllocation, prodomrade);
                        return IsSuccessfull;
                    }
                }

            }
            return IsSuccessfull;
        }


        //Registrering av ny Allokering av personal på produkt
        public bool InsertNewProductAllocation(string persNr, string produktNamn, string procent, string prodomr)
        {
            ResursAllokeringar rA = new ResursAllokeringar();
            ProdukController pC = new ProdukController();
            rA.PersNr = persNr;
            rA.ProcentSats = int.Parse(procent);

            foreach (Produktregister p in pC.Produktlista)
            {
                if (p.produkt == produktNamn && p.avdelningsnamn.Contains(prodomr))
                {
                    rA.ProduktID = p.produktID;
                    break;
                }
            }
            kC = new Technical.KostnadsbudConnection();
            bool IsSuccessfull = kC.InsertStaffAllocationOnProduct(rA);

            return IsSuccessfull;
        }
        //Registrering av ny Allokering av personal på Aktivitet
        public bool InsertNewActivityAllocation(string persNr, string aktivitetsNamn, string procent, string prodomr)
        {
            AktivitetsAllokeringar aA = new AktivitetsAllokeringar();
            AktivitetsController aC = new AktivitetsController();
            IEnumerable<Aktivietetsregister> activities = aC.ComboboxUpdate();
            aA.PersNr = persNr;
            aA.Procentsats = int.Parse(procent);

            foreach (Aktivietetsregister a in activities)
            {
                if (a.aktivitet == aktivitetsNamn && a.avdelningsnamn.Contains(prodomr))
                {
                    aA.AktivitetsID = a.aktivitetsID;
                    break;
                }
            }

            kC = new Technical.KostnadsbudConnection();
            bool IsSuccessfull = kC.InsertStaffAllocationOnActicity(aA);

            return IsSuccessfull;
        }
        //Borttaging av personal allokering på produkt
        public bool RemoveProductAllocation(string persnr, string prodNamn, string currentAllo, string avd)
        {
            pC = new ProdukController();
            ResursAllokeringar rA = new Systemet.ResursAllokeringar();
            rA = CreateProductAllocationObject(persnr, prodNamn, currentAllo, avd);

            kC = new Technical.KostnadsbudConnection();
            bool isSuccessfull = kC.RemoveStaffAllocationOnProducts(rA);
            if (isSuccessfull)
            {
                TriggerDGVupdate();
            }
            return isSuccessfull;
        }

        //Borttaging av personal allokering på produkt
        public bool RemoveActivityAllocation(string persnr, string aktivitetsNamn, string currentAllo, string avd)
        {
            AktivitetsAllokeringar aA = new AktivitetsAllokeringar();
            sKB = (SideViews.SideKostnadsbudgetering)AccessController.Instance.SidMeny;
            aA = CreateActivityAllocationObject(persnr, aktivitetsNamn, currentAllo, avd);
            kC = new Technical.KostnadsbudConnection();
            bool isSuccessfull = kC.RemoveStaffAllocationOnActivity(aA);
            if (isSuccessfull)
            {
                if (avd.Contains("Adm"))
                {
                    sKB.checkBoxResursAdm.Focus();
                    sKB.checkBoxResursAdm.Checked = !sKB.checkBoxResursAdm.Checked;
                }
                if (avd.Contains("mark"))
                {
                    sKB.checkBoxResursForsMark.Focus();
                    sKB.checkBoxResursForsMark.Checked = !sKB.checkBoxResursForsMark.Checked;
                }
            }
            return isSuccessfull;
        }
        //Uppdatera allokering på personal för Produkter
        public bool UpdateStaffAllocationOnProduct(string persnr, string prodNamn, string NewAllo, string avd)
        {
            ResursAllokeringar rA = new ResursAllokeringar();
            kC = new Technical.KostnadsbudConnection();
            rA = CreateProductAllocationObject(persnr, prodNamn, NewAllo, avd);

            bool isSuccessfull = kC.UpdateStaffAllocationOnProducts(rA);
            if (isSuccessfull)
            {
                TriggerDGVupdate();
                return isSuccessfull;
            }
            return isSuccessfull;
        }
        //Uppdatera allokering på personal för Aktiviter
        public bool UpdateStaffAllocationOnActivity(string persnr, string aktivitetsNamn, string NewAllo, string avd)
        {
            AktivitetsAllokeringar aA = new AktivitetsAllokeringar();
            kC = new Technical.KostnadsbudConnection();
            aA = CreateActivityAllocationObject(persnr, aktivitetsNamn, NewAllo, avd);
            sKB = (SideViews.SideKostnadsbudgetering)AccessController.Instance.SidMeny;
            bool isSuccessfull = kC.UpdateStaffAllocationOnActivity(aA);
            if (isSuccessfull)
            {
                if (avd.Contains("Adm"))
                {
                    sKB.checkBoxResursAdm.Focus();
                    sKB.checkBoxResursAdm.Checked = !sKB.checkBoxResursAdm.Checked;
                }
                if (avd.Contains("mark"))
                {
                    sKB.checkBoxResursForsMark.Focus();
                    sKB.checkBoxResursForsMark.Checked = !sKB.checkBoxResursForsMark.Checked;
                }
                return isSuccessfull;
            }
            return isSuccessfull;
        }
        //Skapa ProductAllokeringsobjekt
        public ResursAllokeringar CreateProductAllocationObject(string persnr, string prodNamn, string currentAllo, string avd)
        {
            ResursAllokeringar rA = new ResursAllokeringar();
            pC = new ProdukController();
            rA.PersNr = persnr;
            rA.ProcentSats = int.Parse(currentAllo);
            foreach (Produktregister p in pC.Produktlista)
            {
                if (p.produkt == prodNamn && p.avdelningsnamn.Contains(avd))
                {
                    rA.ProduktID = p.produktID;
                    break;
                }
            }
            return rA;
        }

        //Skapa Aktivitetsallokeringsobjekt
        public AktivitetsAllokeringar CreateActivityAllocationObject(string persnr, string aktivitetsNamn, string currentAllo, string avd)
        {
            AktivitetsAllokeringar aA = new AktivitetsAllokeringar();
            aA.PersNr = persnr;
            aA.Procentsats = int.Parse(currentAllo);
            aC = new Technical.AktivitetConnection();
            foreach (Aktivietetsregister a in aC.getFiltreringskriterier())
            {
                if (a.aktivitet == aktivitetsNamn && a.avdelningsnamn.Contains(avd))
                {
                    aA.AktivitetsID = a.aktivitetsID;
                    break;
                }
            }
            return aA;
        }

        //TRigga en uppdatering av DGV vid Drift eller Utv/Förv
        public void TriggerDGVupdate()
        {
            sKB = (SideViews.SideKostnadsbudgetering)AccessController.Instance.SidMeny;
            sKB.cmBProduktgrupp_SelectedIndexChanged(sKB.cmBProduktgrupp, null);
        }


        //Direktkostnadsbudgetering

        //Clearing av direktkostnadsDatagridview
        public void clearDirectCostDGV()
        {
            DirKostBudgMain = (Views.Direktkostnadsbudgetering)AccessController.Instance.MainView;
            DirKostBudgMain.clearDGV();
        }

        //Direktkostnadsbudgetering produkter
        public void RetrieveSearchedProductsNAccounts(string prodOmr, string prodKate, string prodgrupp, string prodNamn, string prodId, string kfran, string ktill)
        {
            currentDepartment = prodOmr;
            ktill = ChangeAccName(ktill);
            pRC = new Technical.ProduktConnection();
            kC = new Technical.KostnadsbudConnection();
            List<Produkt> produkter = pRC.GetProdukt(prodOmr, prodKate, prodgrupp, prodNamn, prodId);
            List<Kontoregister> accs = kC.GetFilteredAccounts(kfran, ktill);
            List<ProduktKostnad> productCosts = kC.RetrieveProductCosts(kfran, ktill, currentDepartment);
            List<AktivitetsKostnad> activitiyCosts = kC.RetrieveActivityCosts(kfran, ktill, prodOmr);
            DirKostBudgMain = (Views.Direktkostnadsbudgetering)AccessController.Instance.MainView;
            DirKostBudgMain.RetrieveProductsNAccounts(produkter, accs, productCosts, activitiyCosts, prodOmr);

        }
        //Direktkostnadsbudgetering Aktiviteter
        public void RetrieveSearchedActivitiesNAccounts(string prodOmrade, string aktivitetsNamn, string AktivID, string kfran, string ktill)
        {
            currentDepartment = prodOmrade;
            ktill = ChangeAccName(ktill);
            aC = new Technical.AktivitetConnection();
            kC = new Technical.KostnadsbudConnection();

            IEnumerable<Aktivietetsregister> activities = aC.GetAktivitet(prodOmrade, aktivitetsNamn, AktivID);
            List<Kontoregister> accs = kC.GetFilteredAccounts(kfran, ktill);
            List<AktivitetsKostnad> activityCosts = kC.RetrieveActivityCosts(kfran, ktill, prodOmrade);
            List<ProduktKostnad> productCosts = kC.RetrieveProductCosts(kfran, ktill, currentDepartment);
            DirKostBudgMain = (Views.Direktkostnadsbudgetering)AccessController.Instance.MainView;
            DirKostBudgMain.RetrieveActivitiesNAccounts(activities, accs, activityCosts, productCosts, prodOmrade);

        }

        //Insert eller förändringar av direktkostnad på aktivitet eller produkt
        public bool InsertOrUpdateDirectCost(string kontonummer, string newAllocation, string oldAllocation, string AllocationName, string prodomrade, bool isNewAllocation)
        {
            currentDepartment = prodomrade;
            //Om det är en ny allokering av direktkostnad
            if (isNewAllocation)
            {
                kC = new Technical.KostnadsbudConnection();
                if (prodomrade.Contains("Adm") || prodomrade.Contains("mark"))
                {
                    string activID = retriveActivityID(AllocationName);
                    AktivitetsKostnad aK = new AktivitetsKostnad();
                    aK.Kontonummer = kontonummer;
                    aK.AktivitetsID = activID;
                    aK.Belopp = int.Parse(newAllocation);
                    bool isSuccess = kC.InsertDirectActivityCost(aK);
                    if (isSuccess)
                    {
                        TriggerDirectCostDGVUpdate();
                    }
                    return isSuccess;
                }
                if (prodomrade.Contains("Drift") || prodomrade.Contains("Förv"))
                {
                    string prodID = retriveProductID(AllocationName);
                    ProduktKostnad pK = new ProduktKostnad();
                    pK.Kontonummer = kontonummer;
                    pK.ProduktID = prodID;
                    pK.Belopp = int.Parse(newAllocation);
                    bool isSuccess = kC.InsertDirectProductCost(pK);
                    if (isSuccess)
                    {
                        TriggerDirectCostDGVUpdate();
                    }
                    return isSuccess;
                }
            }
            else // OM det är en förändring
            {
                if (prodomrade.Contains("Adm") || prodomrade.Contains("mark"))
                {
                    string activID = retriveActivityID(AllocationName);
                    AktivitetsKostnad aK = new AktivitetsKostnad();
                    aK.Kontonummer = kontonummer;
                    aK.AktivitetsID = activID;
                    aK.Belopp = int.Parse(newAllocation);
                    bool isSuccess = kC.UpdateActivityCost(aK);
                    if (isSuccess)
                    {
                        TriggerDirectCostDGVUpdate();
                    }
                    return isSuccess;
                }
                if (prodomrade.Contains("Drift") || prodomrade.Contains("Förv"))
                {
                    string prodID = retriveProductID(AllocationName);
                    ProduktKostnad pK = new ProduktKostnad();
                    pK.Kontonummer = kontonummer;
                    pK.ProduktID = prodID;
                    pK.Belopp = int.Parse(newAllocation);
                    bool isSuccess = kC.UpdateProductCost(pK);
                    if (isSuccess)
                    {
                        TriggerDirectCostDGVUpdate();
                    }
                    return isSuccess;
                }
            }

            return false;
        }

        //Borttagning av en Direktkostnad på en produkt eller aktivitet
        public bool RemoveDirectCost(string konto, string kolumnNamn, string prodomr)
        {
            currentDepartment = prodomr;
            if (prodomr.Contains("Adm") || prodomr.Contains("mark"))
            {
                kC = new Technical.KostnadsbudConnection();
                bool Issuccess = kC.RemoveDirectCostOnActivity(konto, retriveActivityID(kolumnNamn));
                if (Issuccess)
                {
                    TriggerDirectCostDGVUpdate();
                }
                return Issuccess;
            }
            if (prodomr.Contains("Drift") || prodomr.Contains("Förv"))
            {
                kC = new Technical.KostnadsbudConnection();
                bool Issuccess = kC.RemoveDirectCostOnProduct(konto, retriveProductID(kolumnNamn));
                if (Issuccess)
                {
                    TriggerDirectCostDGVUpdate();
                }
                return Issuccess;
            }

            return false;
        }

        private void TriggerDirectCostDGVUpdate()
        {

            sKB = (SideViews.SideKostnadsbudgetering)AccessController.Instance.SidMeny;
            sKB.UpdateDirectCostMainDGV(currentDepartment);
        }



        private string retriveActivityID(string namn)
        {
            aC = new Technical.AktivitetConnection();
            foreach (Aktivietetsregister a in aC.getFiltreringskriterier())
            {
                if (a.aktivitet == namn)
                {
                    return a.aktivitetsID;
                }
            }
            return null;
        }

        private string retriveProductID(string namn)
        {
            pC = new ProdukController();
            foreach (Produktregister p in pC.Produktlista)
            {
                if (p.produkt == namn)
                {
                    return p.produktID;
                }
            }
            return null;
        }

        public string ChangeAccName(string kontoTill)
        {
            if (kontoTill == "")
            {
                kontoTill = "9999";
            }
            if (kontoTill.Length == 1)
            {
                kontoTill = kontoTill + "999";
            }
            if (kontoTill.Length == 2)
            {
                kontoTill = kontoTill + "99";
            }
            if (kontoTill.Length == 3)
            {
                kontoTill = kontoTill + "9";
            }

            return kontoTill;
        }
        public List<ResursAllokeringar> ReturnResursAllo()
        {
            List<ResursAllokeringar> ra = new List<ResursAllokeringar>();
            pRC = new Technical.ProduktConnection();

            foreach (ResursAllokeringar r in pRC.RetrieveProductAllo(""))
            {
                if (r.Låst == false & r.ÄndratDatum.Year == DateTime.Now.Year)
                {
                    ra.Add(r);
                }
            }

            return ra;
        }

        public List<AktivitetsAllokeringar> ReturnAktivitetsAllo()
        {
            List<AktivitetsAllokeringar> akAllo = new List<AktivitetsAllokeringar>();
            kC = new Technical.KostnadsbudConnection();

            foreach (AktivitetsAllokeringar ar in kC.GetActivityAllocations("Adm"))
            {
                if (ar.Låst == false & ar.ÄndratDatum.Year == DateTime.Now.Year)
                {
                    akAllo.Add(ar);
                }
            }
            //foreach (AktivitetsAllokeringar ar in kC.GetActivityAllocations("mark"))
            //{
            //    if (ar.Låst == false & ar.ÄndratDatum.Year == DateTime.Now.Year)
            //    {
            //        akAllo.Add(ar);
            //    }
            //}

            return akAllo;
        }

        public Dictionary<string, string> reteurnDisponibelt()
        {
            Technical.PersonalConnection pC = new Technical.PersonalConnection();
            Dictionary<string, string> personalDispo = new Dictionary<string, string>();
            List<AktivitetsAllokeringar> aa = new List<AktivitetsAllokeringar>(ReturnAktivitetsAllo());
            List<ResursAllokeringar> ra = new List<ResursAllokeringar>(ReturnResursAllo());
            List<Personalregister> pa = new List<Personalregister>(pC.RetrieveStaff());

            int disponibelt = 0;

            foreach (Personalregister p in pa)
            {
                disponibelt = 0;

                disponibelt = p.Sysselsättningsgrad - p.Vakansavdrag;

                foreach (AktivitetsAllokeringar a in aa)
                {
                    if (p.personnummer == a.PersNr)
                    {
                        if (a.Procentsats != null)
                            disponibelt = disponibelt - (int)a.Procentsats;
                        else
                            disponibelt = disponibelt - 0;
                    }
                }

                foreach (ResursAllokeringar r in ra)
                {
                    if (p.personnummer == r.PersNr)
                    {
                        if (r.ProcentSats != null)
                            disponibelt = disponibelt - (int)r.ProcentSats;
                        else
                            disponibelt = disponibelt - 0;
                    }
                }
                if (disponibelt > 0)
                    personalDispo.Add(p.personnummer, "" + disponibelt);
            }
            return personalDispo;
        }
    }
}
